/** @addtogroup cometa

 *  @{

 */

#pragma once

#include "../cometa.hpp"

#include "cstring.hpp"

#include "ctti.hpp"

#include "named_arg.hpp"

#include <array>

#include <cstdio>

#include <string>

#include <utility>

CMT_PRAGMA_GNU(GCC diagnostic push)

CMT_PRAGMA_GNU(GCC diagnostic ignored "-Wpragmas")

#if CMT_HAS_WARNING("-Wformat-security") || defined CMT_COMPILER_GCC

CMT_PRAGMA_GNU(GCC diagnostic ignored "-Wformat-security")

#endif

CMT_PRAGMA_GNU(GCC diagnostic ignored "-Wused-but-marked-unused")

namespace cometa

{

template <typename T>

struct representation

{

    using type = T;

    static constexpr const T& get(const T& value) noexcept { return value; }

};

template <typename T>

using repr_type = typename representation<T>::type;

template <typename... Args>

CMT_INLINE std::string as_string(const Args&... args);

namespace details

{

template <typename T, char t = static_cast<char>(-1), int width = -1, int prec = -1>

struct fmt_t

{

    const T& value;

};

template <int number, CMT_ENABLE_IF(number >= 0 && number < 10)>

constexpr cstring<2> itoa()

{

    return cstring<2>{ { static_cast<char>(number + '0'), 0 } };

}

template <int number, CMT_ENABLE_IF(number >= 10)>

constexpr auto itoa()

{

    return concat_cstring(itoa<number / 10>(), itoa<number % 10>());

}

template <int number, CMT_ENABLE_IF(number < 0)>

constexpr auto itoa()

{

    return concat_cstring(make_cstring("-"), itoa<-number>());

}

template <typename T, char t, int width, int prec, CMT_ENABLE_IF(width < 0 && prec >= 0)>

CMT_INLINE constexpr auto value_fmt_arg(ctype_t<fmt_t<T, t, width, prec>>)

{

    return concat_cstring(make_cstring("."), itoa<prec>());

}

template <typename T, char t, int width, int prec, CMT_ENABLE_IF(width >= 0 && prec < 0)>

CMT_INLINE constexpr auto value_fmt_arg(ctype_t<fmt_t<T, t, width, prec>>)

{

    return itoa<width>();

}

template <typename T, char t, int width, int prec, CMT_ENABLE_IF(width < 0 && prec < 0)>

CMT_INLINE constexpr auto value_fmt_arg(ctype_t<fmt_t<T, t, width, prec>>)

{

    return make_cstring("");

}

template <typename T, char t, int width, int prec, CMT_ENABLE_IF(width >= 0 && prec >= 0)>

CMT_INLINE constexpr auto value_fmt_arg(ctype_t<fmt_t<T, t, width, prec>>)

{

    return concat_cstring(itoa<width>(), make_cstring("."), itoa<prec>());

}

CMT_INLINE constexpr auto value_fmt(ctype_t<bool>) { return make_cstring("%s"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<std::string>) { return make_cstring("%s"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<char>) { return make_cstring("%d"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<signed char>) { return make_cstring("%d"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<unsigned char>) { return make_cstring("%d"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<short>) { return make_cstring("%d"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<unsigned short>) { return make_cstring("%d"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<int>) { return make_cstring("%d"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<long>) { return make_cstring("%ld"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<long long>) { return make_cstring("%lld"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<unsigned int>) { return make_cstring("%u"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<unsigned long>) { return make_cstring("%lu"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<unsigned long long>) { return make_cstring("%llu"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<float>) { return make_cstring("%g"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<double>) { return make_cstring("%g"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<long double>) { return make_cstring("%Lg"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<const char*>) { return make_cstring("%s"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<char*>) { return make_cstring("%s"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<void*>) { return make_cstring("%p"); }

CMT_INLINE constexpr auto value_fmt(ctype_t<const void*>) { return make_cstring("%p"); }

template <char... chars>

CMT_INLINE constexpr auto value_fmt(ctype_t<cchars_t<chars...>>)

{

    return concat_cstring(make_cstring("%s"), make_cstring(cchars_t<chars...>()));

}

template <typename T>

CMT_INLINE constexpr auto value_fmt(ctype_t<ctype_t<T>>)

{

    return make_cstring("%s");

}

template <typename T, int width, int prec>

CMT_INLINE constexpr auto value_fmt(ctype_t<fmt_t<T, static_cast<char>(-1), width, prec>> fmt)

{

    return concat_cstring(make_cstring("%"), value_fmt_arg(fmt),

                          value_fmt(ctype_t<repr_type<T>>()).slice(csize_t<1>()));

}

template <typename T, char t, int width, int prec>

CMT_INLINE constexpr auto value_fmt(ctype_t<fmt_t<T, t, width, prec>> fmt)

{

    return concat_cstring(make_cstring("%"), value_fmt_arg(fmt), cstring<2>{ { t, 0 } });

}

template <char... chars>

CMT_INLINE const char* pack_value(const cchars_t<chars...>&)

{

    return "";

}

template <typename Arg>

CMT_INLINE const Arg& pack_value(const Arg& value)

{

    return value;

}

CMT_INLINE double pack_value(float value) { return static_cast<double>(value); }

CMT_INLINE auto pack_value(bool value) { return value ? "true" : "false"; }

CMT_INLINE auto pack_value(const std::string& value) { return value.c_str(); }

template <typename T>

CMT_INLINE const char* pack_value(ctype_t<T>)

{

    return type_name<T>();

}

template <typename T, char t, int width, int prec>

CMT_INLINE auto pack_value(const fmt_t<T, t, width, prec>& value)

{

    return pack_value(representation<T>::get(value.value));

}

template <size_t N1, size_t Nnew, size_t... indices>

CMT_INLINE constexpr cstring<N1 - 3 + Nnew> fmt_replace_impl(const cstring<N1>& str,

                                                             const cstring<Nnew>& newfmt,

                                                             csizes_t<indices...>)

{

    size_t start = 0;

    size_t end   = 0;

    cstring<N1 - 3 + Nnew> result;

    for (size_t i = 0; i < N1; i++)

    {

        if (str[i] == '{')

            start = i;

        else if (str[i] == '}')

            end = i;

    }

    if (end - start == 1) // {}

    {

        for (size_t i = 0; i < N1; i++)

        {

            if (i < start)

                result[i] = str[i];

            else if (i == start)

                result[i] = '%';

            else if (i > start && i - start - 1 < Nnew - 1)

                result[i] = newfmt[i - start - 1];

            else if (i - Nnew + 3 < N1 - 1)

                result[i] = str[i - Nnew + 3];

            else

                result[i] = 0;

        }

    }

    return result;

}

template <size_t N1, size_t Nto>

CMT_INLINE constexpr cstring<N1 - 3 + Nto> fmt_replace(const cstring<N1>& str, const cstring<Nto>& newfmt)

{

    return fmt_replace_impl(str, newfmt, csizeseq_t<N1 - 3 + Nto - 1>());

}

inline std::string replace_one(const std::string& str, const std::string& from, const std::string& to)

{

    std::string r    = str;

    size_t start_pos = 0;

    if ((start_pos = r.find(from, start_pos)) != std::string::npos)

    {

        r.replace(start_pos, from.size(), to);

    }

    return r;

}

CMT_INLINE const std::string& build_fmt(const std::string& str, ctypes_t<>) { return str; }

template <typename Arg, typename... Args>

CMT_INLINE auto build_fmt(const std::string& str, ctypes_t<Arg, Args...>)

{

    constexpr auto fmt = value_fmt(ctype_t<decay<Arg>>());

    return build_fmt(replace_one(str, "{}", std::string(fmt.data())), ctypes_t<Args...>());